#2360 Elm Props: Use correct index to id map

ApplicationCode/FileInterface/RifElementPropertyReader.cpp

@@ -20,12 +20,15 @@
 
 #include "cvfAssert.h"
 
+#include <cmath>
+
+#include <QMessageBox>
 #include <QString>
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifElementPropertyReader::RifElementPropertyReader() {}
+RifElementPropertyReader::RifElementPropertyReader(const std::vector<int>& elementIdxToId) : m_elementIdxToId(elementIdxToId) {}
 
 //--------------------------------------------------------------------------------------------------
 ///
@@ -40,7 +43,7 @@ void RifElementPropertyReader::addFile(const std::string& fileName)
     RifElementPropertyMetadata metaData = RifElementPropertyTableReader::readMetadata(QString::fromStdString(fileName));
     for (QString field : metaData.dataColumns)
     {
-        m_fields[field.toStdString()] = metaData;
+        m_fieldsMetaData[field.toStdString()] = metaData;
     }
 }
 
@@ -51,7 +54,8 @@ std::map<std::string, std::vector<std::string>> RifElementPropertyReader::scalar
 {
     std::map<std::string, std::vector<std::string>> fields;
 
-    for (std::map<std::string, RifElementPropertyMetadata>::iterator field = m_fields.begin(); field != m_fields.end(); field++)
+    for (std::map<std::string, RifElementPropertyMetadata>::iterator field = m_fieldsMetaData.begin();
+         field != m_fieldsMetaData.end(); field++)
     {
         fields[field->first];
     }
@@ -66,16 +70,100 @@ std::map<std::string, std::vector<float>>
     RifElementPropertyReader::readAllElementPropertiesInFileContainingField(const std::string& fieldName)
 {
     RifElementPropertyTable table;
-    RifElementPropertyTableReader::readData(&m_fields[fieldName], &table);
+    RifElementPropertyTableReader::readData(&m_fieldsMetaData[fieldName], &table);
 
-    CVF_ASSERT(m_fields[fieldName].dataColumns.size() == table.data.size());
-
-    std::map<std::string, std::vector<float>> fieldAndData;
+    CVF_ASSERT(m_fieldsMetaData[fieldName].dataColumns.size() == table.data.size());
 
     for (size_t i = 0; i < table.data.size(); i++)
     {
-        fieldAndData[m_fields[fieldName].dataColumns[i].toStdString()].swap(table.data[i]);
+        CVF_ASSERT(table.data[i].size() == table.elementIds.size());
+    }
+
+    std::map<std::string, std::vector<float>> fieldAndData;
+
+    const std::vector<int>& elementIdsFromFile = table.elementIds;
+
+    if (elementIdsFromFile == m_elementIdxToId)
+    {
+        for (size_t i = 0; i < table.data.size(); i++)
+        {
+            const std::string& currentFieldFromFile  = m_fieldsMetaData[fieldName].dataColumns[i].toStdString();
+            fieldAndData[currentFieldFromFile] = table.data[i];
+        }
+    }
+    else if (elementIdsFromFile.size() > m_elementIdxToId.size())
+    {
+        RifElementPropertyReader::outputWarningAboutWrongFileData();
+        return fieldAndData;
+    }
+    else
+    {
+        if (m_elementIdToIdx.size() == 0)
+        {
+            makeElementIdToIdxMap();
+        }
+
+        std::vector<int> fileIdxToElementIdx;
+        fileIdxToElementIdx.reserve(elementIdsFromFile.size());
+
+        for (size_t i = 0; i < elementIdsFromFile.size(); i++)
+        {
+            std::unordered_map<int /*elm ID*/, int /*elm idx*/>::const_iterator it = m_elementIdToIdx.find(elementIdsFromFile[i]);
+            if (it == m_elementIdToIdx.end())
+            {
+                RifElementPropertyReader::outputWarningAboutWrongFileData();
+                return fieldAndData;
+            }
+
+            fileIdxToElementIdx.push_back(it->second);
+        }
+
+        for (size_t i = 0; i < table.data.size(); i++)
+        {
+            std::string currentFieldFromFile = m_fieldsMetaData[fieldName].dataColumns[i].toStdString();
+
+            const std::vector<float>& currentColumn = table.data[i];
+
+            std::vector<float> tempResult(m_elementIdToIdx.size(), HUGE_VAL);
+
+            for (size_t j = 0; j < currentColumn.size(); j++)
+            {
+                tempResult[fileIdxToElementIdx[j]] = currentColumn[j];
+            }
+
+            fieldAndData[currentFieldFromFile].swap(tempResult);
+        }
     }
 
     return fieldAndData;
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RifElementPropertyReader::makeElementIdToIdxMap()
+{
+    m_elementIdToIdx.reserve(m_elementIdxToId.size());
+
+    for (size_t i = 0; i < m_elementIdxToId.size(); i++)
+    {
+        m_elementIdToIdx[m_elementIdxToId[i]] = (int)i;
+    }
+
+    std::vector<int> tempVectorForDeletion;
+    m_elementIdxToId.swap(tempVectorForDeletion);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RifElementPropertyReader::outputWarningAboutWrongFileData()
+{
+    QMessageBox msgBox;
+    msgBox.setIcon(QMessageBox::Warning);
+    QString warningText;
+    warningText = QString("The chosen result property does not fit the model");
+    msgBox.setText(warningText);
+    msgBox.setStandardButtons(QMessageBox::Ok);
+    msgBox.exec();
+}

ApplicationCode/FileInterface/RifElementPropertyReader.h

@@ -26,6 +26,7 @@
 
 #include <map>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 //==================================================================================================
@@ -35,7 +36,7 @@
 class RifElementPropertyReader : public cvf::Object
 {
 public:
-    RifElementPropertyReader();
+    RifElementPropertyReader(const std::vector<int>& elementIdxToId);
     virtual ~RifElementPropertyReader();
 
     void addFile(const std::string& fileName);
@@ -45,5 +46,11 @@ public:
     std::map<std::string, std::vector<float>> readAllElementPropertiesInFileContainingField(const std::string& fieldName);
 
 private:
-    std::map<std::string, RifElementPropertyMetadata> m_fields;
+    void makeElementIdToIdxMap();
+    static void outputWarningAboutWrongFileData();
+
+private:
+    std::map<std::string, RifElementPropertyMetadata> m_fieldsMetaData;
+    std::vector<int> m_elementIdxToId;
+    std::unordered_map<int, int> m_elementIdToIdx;
 };

ApplicationCode/GeoMech/GeoMechDataModel/RigFemPart.h

@@ -85,6 +85,7 @@ public:
     cvf::Vec3f                  faceNormal(int elmentIndex, int faceIndex) const;
 
     const RigFemPartGrid*       structGrid() const;   
+    const std::vector<int>&     elementIdxToId() const { return m_elementId; }
 
 private:
     int                         m_elementPartId;

ApplicationCode/GeoMech/GeoMechDataModel/RigGeoMechCaseData.cpp

@@ -97,8 +97,6 @@ bool RigGeoMechCaseData::openAndReadFemParts(std::string* errorMessage)
     m_readerInterface = new RifOdbReader;
 #endif
 
-    m_elementPropertyReader = new RifElementPropertyReader;
-
     if (m_readerInterface.notNull() && m_readerInterface->openFile(m_geoMechCaseFileName, errorMessage))
     {
         m_femParts = new RigFemPartCollection();
@@ -110,6 +108,7 @@ bool RigGeoMechCaseData::openAndReadFemParts(std::string* errorMessage)
             progress.incrementProgress();
             progress.setProgressDescription("Calculating element neighbors");
 
+            m_elementPropertyReader = new RifElementPropertyReader(m_femParts->part(0)->elementIdxToId());
             // Initialize results containers
             m_femPartResultsColl = new RigFemPartResultsCollection(m_readerInterface.p(), m_elementPropertyReader.p(), m_femParts.p());