Initial version of RigGridCollection

p4#: 20514

ApplicationCode/ReservoirDataModel/ReservoirDataModel_UnitTests/RigReservoir-Test.cpp

@@ -22,8 +22,69 @@
 #include "gtest/gtest.h"
 
 #include "RigEclipseCase.h"
+#include "RigGridCollection.h"
 
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+TEST(RigGridCollection, BasicTest)
+{
+    cvf::ref<RigMainGrid> mainGridA = new RigMainGrid;
+
+    cvf::ref<RigEclipseCase> eclipseCase = new RigEclipseCase;
+
+    RigGridCollection gridCollection;
+    gridCollection.addGrid(eclipseCase.p(), mainGridA.p());
+
+    int count = mainGridA->refCount();
+    EXPECT_TRUE(mainGridA->refCount() == 2);
+
+    cvf::ref<RigMainGrid> mainGridB = mainGridA;
+    EXPECT_TRUE(mainGridA->refCount() == 3);
+
+    cvf::ref<RigMainGrid> existingGrid = gridCollection.findEqualGrid(mainGridB.p());
+    EXPECT_TRUE(existingGrid.notNull());
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+TEST(RigGridCollection, EqualTests)
+{
+    cvf::ref<RigMainGrid> mainGridA = new RigMainGrid;
+    mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 0));
+    mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 1));
+    mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 2));
+
+    cvf::ref<RigEclipseCase> eclipseCase = new RigEclipseCase;
+
+    RigGridCollection gridCollection;
+    gridCollection.addGrid(eclipseCase.p(), mainGridA.p());
+
+
+    cvf::ref<RigMainGrid> mainGridB = new RigMainGrid;
+    cvf::ref<RigMainGrid> existingGrid = gridCollection.findEqualGrid(mainGridB.p());
+    EXPECT_TRUE(existingGrid.isNull());
+
+    mainGridB->nodes().push_back(cvf::Vec3d(0, 0, 0));
+    existingGrid = gridCollection.findEqualGrid(mainGridB.p());
+    EXPECT_TRUE(existingGrid.isNull());
+
+    // Insert nodes in opposite direction
+    mainGridB->nodes().push_back(cvf::Vec3d(0, 0, 2));
+    mainGridB->nodes().push_back(cvf::Vec3d(0, 0, 1));
+    existingGrid = gridCollection.findEqualGrid(mainGridB.p());
+    EXPECT_TRUE(existingGrid.isNull());
+
+    // Overwrite to match the node structure of mainGridA
+    mainGridB->nodes()[1] = cvf::Vec3d(0, 0, 1);
+    mainGridB->nodes()[2] = cvf::Vec3d(0, 0, 2);
+    existingGrid = gridCollection.findEqualGrid(mainGridB.p());
+    EXPECT_TRUE(existingGrid.notNull());
+
+}
+
 /*
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ReservoirDataModel/RigGridCollection.cpp

@@ -17,4 +17,76 @@
 /////////////////////////////////////////////////////////////////////////////////
 
 #include "RigGridCollection.h"
+#include "RigEclipseCase.h"
+#include "RigMainGrid.h"
 
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigGridCollection::addGrid(RigEclipseCase* eclipseCase, RigMainGrid* mainGrid)
+{
+    m_caseToGrid.push_back(CaseToGridMap(eclipseCase, mainGrid));
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigGridCollection::removeCase(RigEclipseCase* eclipseCase)
+{
+    size_t indexToErase = cvf::UNDEFINED_SIZE_T;
+
+    for (size_t i = 0; i < m_caseToGrid.size(); i++)
+    {
+        if (m_caseToGrid[i].m_eclipseCase == eclipseCase)
+        {
+            indexToErase = i;
+        }
+    }
+
+    if (indexToErase != cvf::UNDEFINED_SIZE_T)
+    {
+        m_caseToGrid.erase(m_caseToGrid.begin() + indexToErase);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigMainGrid* RigGridCollection::findEqualGrid(RigMainGrid* candidateGrid)
+{
+    for (size_t i = 0; i < m_caseToGrid.size(); i++)
+    {
+        RigMainGrid* mainGrid = m_caseToGrid.at(i).m_mainGrid.p();
+        if (RigGridCollection::isEqual(mainGrid, candidateGrid))
+        {
+            return mainGrid;
+        }
+    }
+    return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RigGridCollection::isEqual(RigMainGrid* gridA, RigMainGrid* gridB)
+{
+    if (gridA == NULL || gridB == NULL) return false;
+
+    if (gridA == gridB) return true;
+
+    if (gridA->gridCount() != gridB->gridCount()) return false;
+
+    if (gridA->nodes().size() != gridB->nodes().size()) return false;
+
+    for (size_t i = 0; i < gridA->nodes().size(); i++)
+    {
+        if (!gridA->nodes()[i].equals(gridB->nodes()[i]))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}

ApplicationCode/ReservoirDataModel/RigGridCollection.h

@@ -18,3 +18,41 @@
 
 #pragma once
 
+#include "cvfBase.h"
+#include "cvfObject.h"
+#include "cvfCollection.h"
+
+#include <vector>
+
+class RigMainGrid;
+class RigEclipseCase;
+
+class RigGridCollection
+{
+public:
+    void addGrid(RigEclipseCase* eclipseCase, RigMainGrid* mainGrid);
+    void removeCase(RigEclipseCase* eclipseCase);
+    
+    RigMainGrid* findEqualGrid(RigMainGrid* candidateGrid);
+
+private:
+
+    static bool isEqual(RigMainGrid* gridA, RigMainGrid* gridB);
+
+    class CaseToGridMap
+    {
+    public:
+        CaseToGridMap(RigEclipseCase* eclipseCase, RigMainGrid* mainGrid) :
+            m_eclipseCase(eclipseCase),
+            m_mainGrid(mainGrid)
+        {
+        }
+
+        cvf::ref<RigEclipseCase>    m_eclipseCase;
+        cvf::ref<RigMainGrid>       m_mainGrid;
+    };
+
+
+private:
+    std::vector<CaseToGridMap> m_caseToGrid;
+};