Read grid dimensions and verify equality before adding a result case

Harmonized and refactored creation of RimResultCases
p4#: 21156

ApplicationCode/Application/RiaApplication.cpp

@@ -56,6 +56,7 @@
 #include "RiaImageCompareReporter.h"
 #include "RiaImageFileCompare.h"
 #include "cafProgressInfo.h"
+#include "RigGridManager.h"
 
 namespace caf
 {
@@ -494,10 +495,7 @@ bool RiaApplication::openEclipseCase(const QString& caseName, const QString& cas
     QFileInfo gridFileName(caseFileName);
     QString casePath = gridFileName.absolutePath();
 
-    RimResultCase* rimResultReservoir = new RimResultCase();
+    RimResultCase* rimResultReservoir = new RimResultCase(caseName, caseFileName, casePath);
-    rimResultReservoir->caseName = caseName;
-    rimResultReservoir->caseFileName = caseFileName;
-    rimResultReservoir->caseDirectory = casePath;
 
     m_project->reservoirs.push_back(rimResultReservoir);
 
@@ -1356,11 +1354,11 @@ bool RiaApplication::addEclipseCases(const QStringList& fileNames)
 {
     if (fileNames.size() == 0) return true;
 
-
     // First file is read completely including grid.
     // The main grid from the first case is reused directly in for the other cases. 
     // When reading active cell info, only the total cell count is tested for consistency
-    RigCaseData* mainEclipseCase = NULL;
+    RimResultCase* mainResultCase = NULL;
+    std::vector< std::vector<int> > mainCaseGridDimensions;
 
     {
         QString firstFileName = fileNames[0];
@@ -1369,46 +1367,54 @@ bool RiaApplication::addEclipseCases(const QStringList& fileNames)
         QString caseName = gridFileName.completeBaseName();
         QString casePath = gridFileName.absolutePath();
 
-        RimResultCase* rimResultReservoir = new RimResultCase();
+        RimResultCase* rimResultReservoir = new RimResultCase(caseName, firstFileName, casePath);
-        rimResultReservoir->caseName = caseName;
-        rimResultReservoir->caseFileName = firstFileName;
-        rimResultReservoir->caseDirectory = casePath;
-
-        m_project->reservoirs.push_back(rimResultReservoir);
-
         if (!rimResultReservoir->openEclipseGridFile())
         {
+            delete rimResultReservoir;
+
             return false;
         }
 
+        rimResultReservoir->readGridDimensions(mainCaseGridDimensions);
+
+        m_project->reservoirs.push_back(rimResultReservoir);
         m_project->moveEclipseCaseIntoCaseGroup(rimResultReservoir);
 
-        mainEclipseCase = rimResultReservoir->reservoirData();
+        mainResultCase = rimResultReservoir;
     }
 
     caf::ProgressInfo info(fileNames.size(), "Reading Active Cell data");
 
     for (int i = 1; i < fileNames.size(); i++)
     {
-        QString fileName = fileNames[i];
+        QString caseFileName = fileNames[i];
-        QFileInfo gridFileName(fileName);
+        QFileInfo gridFileName(caseFileName);
 
         QString caseName = gridFileName.completeBaseName();
         QString casePath = gridFileName.absolutePath();
 
-        RimResultCase* rimResultReservoir = new RimResultCase();
+        RimResultCase* rimResultReservoir = new RimResultCase(caseName, caseFileName, casePath);
-        rimResultReservoir->caseName = caseName;
-        rimResultReservoir->caseFileName = fileName;
-        rimResultReservoir->caseDirectory = casePath;
 
-        m_project->reservoirs.push_back(rimResultReservoir);
+        std::vector< std::vector<int> > caseGridDimensions;
+        rimResultReservoir->readGridDimensions(caseGridDimensions);
 
-        if (!rimResultReservoir->openAndReadActiveCellData(mainEclipseCase))
+        bool identicalGrid = RigGridManager::isGridDimensionsEqual(mainCaseGridDimensions, caseGridDimensions);
+        if (identicalGrid)
         {
-            return false;
+            if (rimResultReservoir->openAndReadActiveCellData(mainResultCase->reservoirData()))
-        }
+            {
-
+                m_project->reservoirs.push_back(rimResultReservoir);
                 m_project->moveEclipseCaseIntoCaseGroup(rimResultReservoir);
+            }
+            else
+            {
+                delete rimResultReservoir;
+            }
+        }
+        else
+        {
+            delete rimResultReservoir;
+        }
 
         info.setProgress(i);
     }

ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp

@@ -30,6 +30,7 @@
 #include "RimResultCase.h"
 #include "cafProgressInfo.h"
 #include "RigActiveCellInfo.h"
+#include "RigGridManager.h"
 
 
 CAF_PDM_SOURCE_INIT(RimIdenticalGridCaseGroup, "RimIdenticalGridCaseGroup");
@@ -78,14 +79,14 @@ void RimIdenticalGridCaseGroup::addCase(RimCase* reservoir)
 
     if (!reservoir) return;
 
-    RigMainGrid* incomingMainGrid = reservoir->reservoirData()->mainGrid();
-
     if (!m_mainGrid)
     {
-        m_mainGrid = incomingMainGrid;
+        m_mainGrid = reservoir->reservoirData()->mainGrid();
+    }
+    else
+    {
+        reservoir->reservoirData()->setMainGrid(m_mainGrid);
     }
-
-    CVF_ASSERT(m_mainGrid == incomingMainGrid);
 
     caseCollection()->reservoirs().push_back(reservoir);
 
@@ -423,3 +424,26 @@ RimCase* RimIdenticalGridCaseGroup::mainCase()
         return NULL;
     }
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RimIdenticalGridCaseGroup::canCaseBeAdded(RimCase* reservoir) const
+{
+    CVF_ASSERT(reservoir && reservoir->reservoirData() && reservoir->reservoirData()->mainGrid());
+
+    if (!m_mainGrid)
+    {
+        // Empty case group, reservoir can be added
+        return true;
+    }
+
+    RigMainGrid* incomingMainGrid = reservoir->reservoirData()->mainGrid();
+    
+    if (RigGridManager::isEqual(m_mainGrid, incomingMainGrid))
+    {
+        return true;
+    }
+
+    return false;
+}

ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.h

@@ -49,7 +49,9 @@ public:
 
     void                                addCase(RimCase* reservoir);
     void                                removeCase(RimCase* reservoir);
+
     bool                                contains(RimCase* reservoir) const;
+    bool                                canCaseBeAdded(RimCase* reservoir) const;
 
     RimStatisticsCase*                  createAndAppendStatisticsCase();
 

ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.cpp

@@ -37,6 +37,7 @@
 #include "RimInputCase.h"
 #include "RimStatisticsCase.h"
 #include "RimResultCase.h"
+#include "RigGridManager.h"
 
 //--------------------------------------------------------------------------------------------------
 /// 
@@ -592,19 +593,29 @@ void RimUiTreeModelPdm::addObjects(const QModelIndex& itemIndex, caf::PdmObjectG
     CVF_ASSERT(proj);
 
     RimIdenticalGridCaseGroup* gridCaseGroup = gridCaseGroupFromItemIndex(itemIndex);
-
     if (gridCaseGroup)
     {
         std::vector<caf::PdmPointer<RimResultCase> > typedObjects;
         pdmObjects.createCopyByType(&typedObjects);
 
-        RigCaseData* mainEclipseCase = NULL;
+        if (typedObjects.size() == 0)
-        if (gridCaseGroup->caseCollection()->reservoirs().size() > 0)
         {
-            RimCase* mainReservoir = gridCaseGroup->caseCollection()->reservoirs()[0];
+            return;
-            mainEclipseCase = mainReservoir->reservoirData();
         }
 
+        RimResultCase* mainResultCase = NULL;
+        std::vector< std::vector<int> > mainCaseGridDimensions;
+
+        // Read out main grid and main grid dimensions if present in case group
+        if (gridCaseGroup->mainCase())
+        {
+            mainResultCase = dynamic_cast<RimResultCase*>(gridCaseGroup->mainCase());
+            CVF_ASSERT(mainResultCase);
+
+            mainResultCase->readGridDimensions(mainCaseGridDimensions);
+        }
+
+        // Add cases to case group
         for (size_t i = 0; i < typedObjects.size(); i++)
         {
             RimResultCase* rimResultReservoir = typedObjects[i];
@@ -614,14 +625,25 @@ void RimUiTreeModelPdm::addObjects(const QModelIndex& itemIndex, caf::PdmObjectG
                 continue;
             }
 
-            if (gridCaseGroup->mainGrid() == NULL)
+            if (!mainResultCase)
             {
                 rimResultReservoir->openEclipseGridFile();
-                mainEclipseCase = rimResultReservoir->reservoirData();
+                rimResultReservoir->readGridDimensions(mainCaseGridDimensions);
+
+                mainResultCase = rimResultReservoir;
             }
             else
             {
-                if (!rimResultReservoir->openAndReadActiveCellData(mainEclipseCase))
+                std::vector< std::vector<int> > caseGridDimensions;
+                rimResultReservoir->readGridDimensions(caseGridDimensions);
+                
+                bool identicalGrid = RigGridManager::isGridDimensionsEqual(mainCaseGridDimensions, caseGridDimensions);
+                if (!identicalGrid)
+                {
+                    continue;
+                }
+
+                if (!rimResultReservoir->openAndReadActiveCellData(mainResultCase->reservoirData()))
                 {
                     CVF_ASSERT(false);
                 }

ApplicationCode/ReservoirDataModel/RigGridManager.cpp

@@ -96,6 +96,29 @@ void RigGridManager::clear()
     m_caseToGrid.clear();
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RigGridManager::isGridDimensionsEqual(const std::vector< std::vector<int> >& mainCaseGridDimensions, const std::vector< std::vector<int> >& caseGridDimensions)
+{
+    if (mainCaseGridDimensions.size() != caseGridDimensions.size())
+    {
+        return false;
+    }
+
+    for (size_t j = 0; j < mainCaseGridDimensions.size(); j++)
+    {
+        if (mainCaseGridDimensions[j].size() != 3) return false;
+        if (caseGridDimensions[j].size() != 3) return false;
+
+        if (mainCaseGridDimensions[j][0] != caseGridDimensions[j][0]) return false;
+        if (mainCaseGridDimensions[j][1] != caseGridDimensions[j][1]) return false;
+        if (mainCaseGridDimensions[j][2] != caseGridDimensions[j][2]) return false;
+    }
+
+    return true;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ReservoirDataModel/RigGridManager.h

@@ -38,10 +38,9 @@ public:
 
     void clear();
 
-private:
-
     static bool isEqual(RigMainGrid* gridA, RigMainGrid* gridB);
-
+    static bool isGridDimensionsEqual(const std::vector< std::vector<int> >& mainCaseGridDimensions, const std::vector< std::vector<int> >& caseGridDimensions);
+private:
     class CaseToGridMap : public cvf::Object
     {
     public: