Version 0.8.6

Author: Magne Sjaastad

ApplicationCode/Application/RIApplication.cpp

@@ -331,6 +331,8 @@ bool RIApplication::closeProject(bool askToSaveIfDirty)
 {
     RIMainWindow* mainWnd = RIMainWindow::instance();
 
+    terminateProcess();
+
     if (false)
     {
         QMessageBox msgBox(mainWnd);
@@ -353,7 +355,7 @@ bool RIApplication::closeProject(bool askToSaveIfDirty)
 
     mainWnd->cleanupGuiBeforeProjectClose();
 
-    caf::EffectCache::instance()->clear();
+    caf::EffectGenerator::clearEffectCache();
     m_project->close();
 
     onProjectOpenedOrClosed();
@@ -417,16 +419,19 @@ bool RIApplication::openEclipseCase(const QString& caseName, const QString& case
 
     RimReservoirView* riv = rimResultReservoir->createAndAddReservoirView();
 
-    // Select SOIL as default result variable
-    riv->cellResult()->resultType = RimDefines::DYNAMIC_NATIVE;
-    riv->cellResult()->resultVariable = "SOIL";
-    riv->animationMode = true;
+    if (m_preferences->autocomputeSOIL)
+    {
+        // Select SOIL as default result variable
+        riv->cellResult()->resultType = RimDefines::DYNAMIC_NATIVE;
+        riv->cellResult()->resultVariable = "SOIL";
+        riv->animationMode = true;
+    }
 
     riv->loadDataAndUpdate();
 
     if (!riv->cellResult()->hasResult())
     {
-        riv->cellResult()->resultVariable = RimDefines::nonSelectedResultName();
+        riv->cellResult()->resultVariable = RimDefines::undefinedResultName();
     }
 
     onProjectOpenedOrClosed();
@@ -455,7 +460,7 @@ bool RIApplication::openInputEclipseCase(const QString& caseName, const QStringL
 
     if (!riv->cellResult()->hasResult())
     {
-        riv->cellResult()->resultVariable = RimDefines::nonSelectedResultName();
+        riv->cellResult()->resultVariable = RimDefines::undefinedResultName();
     }
 
     onProjectOpenedOrClosed();
@@ -536,10 +541,12 @@ void RIApplication::setUseShaders(bool enable)
 //--------------------------------------------------------------------------------------------------
 bool RIApplication::useShaders() const
 {
+    if (!m_preferences->useShaders) return false;
+
     bool isShadersSupported = caf::Viewer::isShadersSupported();
     if (!isShadersSupported) return false;
 
-    return m_preferences->useShaders;
+    return true;
 }
 
 
@@ -721,7 +728,7 @@ void RIApplication::slotWorkerProcessFinished(int exitCode, QProcess::ExitStatus
     // get a chance to run before we delete the object
     if (m_workerProcess)
     {
-        m_workerProcess->deleteLater();
+        m_workerProcess->close();
     }
     m_workerProcess = NULL;
 
@@ -749,23 +756,33 @@ void RIApplication::slotWorkerProcessFinished(int exitCode, QProcess::ExitStatus
 //--------------------------------------------------------------------------------------------------
 bool RIApplication::launchProcess(const QString& program, const QStringList& arguments)
 {
-    m_workerProcess = new caf::UiProcess(this);
-    connect(m_workerProcess, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(slotWorkerProcessFinished(int, QProcess::ExitStatus)));
+    if (m_workerProcess == NULL)
+    {
+        m_workerProcess = new caf::UiProcess(this);
+        connect(m_workerProcess, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(slotWorkerProcessFinished(int, QProcess::ExitStatus)));
 
-    RIMainWindow::instance()->processMonitor()->startMonitorWorkProcess(m_workerProcess);
+        RIMainWindow::instance()->processMonitor()->startMonitorWorkProcess(m_workerProcess);
 
-    m_workerProcess->start(program, arguments);
-    if (!m_workerProcess->waitForStarted(1000))
-    {
-        m_workerProcess->deleteLater();
-        m_workerProcess = NULL;
+        m_workerProcess->start(program, arguments);
+        if (!m_workerProcess->waitForStarted(1000))
+        {
+            m_workerProcess->close();
+            m_workerProcess = NULL;
+
+            RIMainWindow::instance()->processMonitor()->stopMonitorWorkProcess();
 
-        RIMainWindow::instance()->processMonitor()->stopMonitorWorkProcess();
+            QMessageBox::warning(RIMainWindow::instance(), "Script execution", "Failed to start script executable located at\n" + program);
 
+            return false;
+        }
+
+        return true;
+    }
+    else
+    {
+        QMessageBox::warning(NULL, "Script execution", "An Octave process is still running. Please stop this process before executing a new script.");
         return false;
     }
-
-    return true;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -853,3 +870,16 @@ void RIApplication::applyPreferences()
     }
 
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RIApplication::terminateProcess()
+{
+    if (m_workerProcess)
+    {
+        m_workerProcess->close();
+    }
+
+    m_workerProcess = NULL;
+}

ApplicationCode/Application/RIApplication.h

@@ -103,6 +103,7 @@ class RIApplication : public QApplication
     QString             octavePath() const;
 
     bool                launchProcess(const QString& program, const QStringList& arguments);
+    void                terminateProcess();
 
     RIPreferences*      preferences();
     void                readPreferences();

ApplicationCode/Application/RIPreferences.cpp

@@ -42,6 +42,8 @@ RIPreferences::RIPreferences(void)
 
     CAF_PDM_InitFieldNoDefault(&lastUsedProjectFileName,"lastUsedProjectFileName", "Last Used Project File", "", "", "");
     lastUsedProjectFileName.setUiHidden(true);
+
+    CAF_PDM_InitField(&autocomputeSOIL,                 "autocomputeSOIL", true, "Compute SOIL if not on disk", "", "", "");
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Application/RIPreferences.h

@@ -41,6 +41,9 @@ class RIPreferences : public caf::PdmObject
 
     caf::PdmField<QString>  lastUsedProjectFileName;
 
+    caf::PdmField<bool>     autocomputeSOIL;
+
+
 protected:
     virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute);
 };

ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp

@@ -66,7 +66,7 @@ bool RifEclipseInputFileTools::openGridFile(const QString& fileName, RigReservoi
     FILE* gridFilePointer = util_fopen(fileName.toLatin1().data(), "r");
     if (!gridFilePointer) return false;
 
-    // Main grid Dimentions
+    // Main grid dimensions
     // SPECGRID - This is whats normally available, but not really the input to Eclipse.
     // DIMENS - Is what Eclipse expects and uses, but is not defined in the GRID section and is not (?) available normally
     // ZCORN, COORD, ACTNUM, MAPAXES

ApplicationCode/FileInterface/RifEclipseOutputFileTools.cpp

@@ -25,6 +25,7 @@
 #endif //USE_ECL_LIB
 
 #include <QFileInfo>
+#include "cafProgressInfo.h"
 
 //--------------------------------------------------------------------------------------------------
 /// Constructor
@@ -105,7 +106,11 @@ bool RifEclipseOutputFileTools::keywordsOnFile(QStringList* keywords, size_t num
     CVF_ASSERT(keywords);
     keywords->clear();
 
+
     size_t numKeywords = ecl_file_get_num_distinct_kw(m_file);
+
+    caf::ProgressInfo info(numKeywords, "Reading Keywords on file");
+
     size_t i;
     for (i = 0; i < numKeywords; i++)
     {
@@ -148,6 +153,8 @@ bool RifEclipseOutputFileTools::keywordsOnFile(QStringList* keywords, size_t num
         {
             keywords->append(QString(kw));
         }
+
+        info.setProgress(i);
     }
 
     return true;

ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp

@@ -142,7 +142,15 @@ QStringList RifEclipseRestartFilesetAccess::resultNames()
 bool RifEclipseRestartFilesetAccess::results(const QString& resultName, size_t timeStep, std::vector<double>* values)
 {
     size_t numOccurrences = m_files[timeStep]->numOccurrences(resultName);
-    CVF_ASSERT(m_numGrids == numOccurrences);
+
+    // No results for this result variable for current time step found
+    if (numOccurrences == 0) return true;
+
+    // Result handling depends on presens of result values for all grids
+    if (m_numGrids != numOccurrences)
+    {
+        return false;
+    }
 
     size_t i;
     for (i = 0; i < numOccurrences; i++)

ApplicationCode/FileInterface/RifReaderEclipseInput.cpp

@@ -67,7 +67,7 @@ bool RifReaderEclipseInput::open(const QString& fileName, RigReservoir* reservoi
     close();
 
     // Should we handle gridless properties ?
-    //    If so, they must match dimentions, and a grid afterwards must match dimension
+    //    If so, they must match dimensions, and a grid afterwards must match dimension
 
     // Add file:
     //   Open file

ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -381,7 +381,11 @@ bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir)
         QStringList staticResultNames = staticResults;
 
         QList<QDateTime> staticDate;
-        staticDate.push_back(m_timeSteps.front());
+        if (m_timeSteps.size() > 0)
+        {
+            staticDate.push_back(m_timeSteps.front());
+        }
+
         for (size_t i = 0; i < static_cast<size_t>(staticResultNames.size()); ++i)
         {
             size_t resIndex = resCellResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, staticResultNames[i]);

ApplicationCode/ModelVisualization/RivCellEdgeEffectGenerator.cpp

@@ -44,6 +44,7 @@
 #include "cvfTexture.h"
 #include "cvfSampler.h"
 #include "cvfScalarMapper.h"
+#include "cafEffectGenerator.h"
 
 
 //--------------------------------------------------------------------------------------------------
@@ -87,22 +88,16 @@ void RivCellEdgeGeometryGenerator::addCellEdgeResultsToDrawableGeo(
     const RigGridBase* grid = dynamic_cast<const RigGridBase*>(generator->activeGrid());
 
     CVF_ASSERT(grid != NULL);
-    const std::vector< double >* cellScalarResults = NULL;
-    bool cellScalarResultUseGlobalActiveIndex = true;
 
-    const std::vector< double >* edgeScalarResults[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
+    bool cellScalarResultUseGlobalActiveIndex = true;
     bool edgeScalarResultUseGlobalActiveIndex[6];
 
     if (cellResultSlot->hasResult())
     {
-        const std::vector< std::vector<double> >& scalarResultTimeSteps = grid->mainGrid()->results()->cellScalarResults(cellResultSlot->gridScalarIndex());
-        if (cellResultSlot->hasDynamicResult())
-        {
-            cellScalarResults = &scalarResultTimeSteps[timeStepIndex];
-        }
-        else
+        if (!cellResultSlot->hasDynamicResult())
         {
-            cellScalarResults = &scalarResultTimeSteps[0];
+            // Static result values are located at time step 0
+            timeStepIndex = 0;
         }
 
         cellScalarResultUseGlobalActiveIndex = grid->mainGrid()->results()->isUsingGlobalActiveIndex(cellResultSlot->gridScalarIndex());
@@ -118,8 +113,6 @@ void RivCellEdgeGeometryGenerator::addCellEdgeResultsToDrawableGeo(
         {
             if (resultIndices[cubeFaceIdx] != cvf::UNDEFINED_SIZE_T)
             {
-                const std::vector< std::vector<double> >& scalarResultTimeSteps = grid->mainGrid()->results()->cellScalarResults(resultIndices[cubeFaceIdx]);
-                edgeScalarResults[cubeFaceIdx] = &scalarResultTimeSteps[0]; // Assuming only static edge results
                 edgeScalarResultUseGlobalActiveIndex[cubeFaceIdx] = grid->mainGrid()->results()->isUsingGlobalActiveIndex(resultIndices[cubeFaceIdx]);
             }
         }
@@ -143,18 +136,16 @@ void RivCellEdgeGeometryGenerator::addCellEdgeResultsToDrawableGeo(
         float cellColorTextureCoord = 0.5f; // If no results exists, the texture will have a special color
         size_t cellIndex = quadToCell[quadIdx];
 
-        size_t resultIndex = cellIndex;
+        size_t resultValueIndex = cellIndex;
         if (cellScalarResultUseGlobalActiveIndex)
         {
-            resultIndex = grid->cell(cellIndex).globalActiveIndex();
+            resultValueIndex = grid->cell(cellIndex).globalActiveIndex();
         }
 
-        if (cellScalarResults )
         {
-            if (resultIndex != cvf::UNDEFINED_SIZE_T)
+            double scalarValue = grid->mainGrid()->results()->cellScalarResult(timeStepIndex, cellResultSlot->gridScalarIndex(), resultValueIndex);
+            if (scalarValue != HUGE_VAL)
             {
-                double scalarValue = (*cellScalarResults)[resultIndex];
-
                 cellColorTextureCoord = cellResultScalarMapper->mapToTextureCoord(scalarValue)[0];
             }
             else
@@ -174,19 +165,17 @@ void RivCellEdgeGeometryGenerator::addCellEdgeResultsToDrawableGeo(
         {
             edgeColor = -1.0f; // Undefined texture coord. Shader handles this.
 
-            resultIndex = cellIndex;
+            resultValueIndex = cellIndex;
             if (edgeScalarResultUseGlobalActiveIndex[cubeFaceIdx])
             {
-                resultIndex = grid->cell(cellIndex).globalActiveIndex();
+                resultValueIndex = grid->cell(cellIndex).globalActiveIndex();
             }
 
-            if (resultIndices[cubeFaceIdx] != cvf::UNDEFINED_SIZE_T && resultIndex != cvf::UNDEFINED_SIZE_T)
+            // Assuming static values to be mapped onto cell edge, always using time step zero
+            double scalarValue = grid->mainGrid()->results()->cellScalarResult(0, resultIndices[cubeFaceIdx], resultValueIndex);
+            if (scalarValue != HUGE_VAL && scalarValue != ignoredScalarValue)
             {
-                double scalarValue = (*(edgeScalarResults[cubeFaceIdx]))[resultIndex];
-                if(scalarValue != ignoredScalarValue)
-                {
-                    edgeColor = edgeResultScalarMapper->mapToTextureCoord(scalarValue)[0];
-                }
+                edgeColor = edgeResultScalarMapper->mapToTextureCoord(scalarValue)[0];
             }
 
             cvf::FloatArray* colArr = cellEdgeColorTextureCoordsArrays.at(cubeFaceIdx);
@@ -250,6 +239,20 @@ bool CellEdgeEffectGenerator::isEqual(const EffectGenerator* other) const
         && m_defaultCellColor     == otherCellFaceEffectGenerator->m_defaultCellColor
         )
     {
+        cvf::ref<cvf::TextureImage> texImg2 = new cvf::TextureImage;
+
+        if (otherCellFaceEffectGenerator->m_edgeScalarMapper.notNull())
+        {
+            otherCellFaceEffectGenerator->m_edgeScalarMapper->updateTexture(texImg2.p());
+            if (!caf::ScalarMapperEffectGenerator::isImagesEqual(m_edgeTextureImage.p(), texImg2.p())) return false;
+        }
+
+        if (otherCellFaceEffectGenerator->m_cellScalarMapper.notNull())
+        {
+            otherCellFaceEffectGenerator->m_cellScalarMapper->updateTexture(texImg2.p());
+            if (!caf::ScalarMapperEffectGenerator::isImagesEqual(m_cellTextureImage.p(), texImg2.p())) return false;
+        }
+
         return true;
     }
     else
@@ -264,6 +267,9 @@ bool CellEdgeEffectGenerator::isEqual(const EffectGenerator* other) const
 caf::EffectGenerator* CellEdgeEffectGenerator::copy() const
 {
     CellEdgeEffectGenerator * newEffect = new CellEdgeEffectGenerator(m_edgeScalarMapper.p(), m_cellScalarMapper.p());
+    newEffect->m_edgeTextureImage = m_edgeTextureImage;
+    newEffect->m_cellTextureImage = m_cellTextureImage;
+
     newEffect->setOpacityLevel(m_opacityLevel);
     newEffect->setCullBackfaces(m_cullBackfaces);
     newEffect->setUndefinedColor(m_undefinedColor);
@@ -316,23 +322,25 @@ void CellEdgeEffectGenerator::updateForShaderBasedRendering(cvf::Effect* effect)
 
     // Set up textures
 
-    cvf::ref<cvf::TextureImage> edgeTexImg = new cvf::TextureImage;
-    cvf::ref<cvf::TextureImage> cellTexImg = new cvf::TextureImage;
+    m_edgeTextureImage = new cvf::TextureImage;
+    m_cellTextureImage = new cvf::TextureImage;
 
-    m_edgeScalarMapper->updateTexture(edgeTexImg.p());
+    cvf::ref<cvf::TextureImage> modifiedCellTextImage;
+    m_edgeScalarMapper->updateTexture(m_edgeTextureImage.p());
     if (m_cellScalarMapper.notNull()) 
     {
-        m_cellScalarMapper->updateTexture(cellTexImg.p());
-        cellTexImg = caf::ScalarMapperEffectGenerator::addAlphaAndUndefStripes(cellTexImg.p(), m_undefinedColor, m_opacityLevel);
+        m_cellScalarMapper->updateTexture(m_cellTextureImage.p());
+        modifiedCellTextImage = caf::ScalarMapperEffectGenerator::addAlphaAndUndefStripes(m_cellTextureImage.p(), m_undefinedColor, m_opacityLevel);
     }
     else 
     {
-        cellTexImg->allocate(2,1);
-        cellTexImg->fill(cvf::Color4ub(cvf::Color4f(m_defaultCellColor, m_opacityLevel)));
+        modifiedCellTextImage = new cvf::TextureImage;
+        modifiedCellTextImage->allocate(2,1);
+        modifiedCellTextImage->fill(cvf::Color4ub(cvf::Color4f(m_defaultCellColor, m_opacityLevel)));
     }
 
-    cvf::ref<cvf::Texture> edgeTexture = new cvf::Texture(edgeTexImg.p());
-    cvf::ref<cvf::Texture> cellTexture = new cvf::Texture(cellTexImg.p());
+    cvf::ref<cvf::Texture> edgeTexture = new cvf::Texture(m_edgeTextureImage.p());
+    cvf::ref<cvf::Texture> cellTexture = new cvf::Texture(modifiedCellTextImage.p());
 
     cvf::ref<cvf::Sampler> sampler = new cvf::Sampler;
     sampler->setWrapMode(cvf::Sampler::CLAMP_TO_EDGE);