Added support for building of metadata from existing time steps

Improved statistics calculation for opening single time step files
Close all dynamic access files when a time step statistics is complete
p4#: 20756

ApplicationCode/Application/RIApplication.cpp

@@ -55,6 +55,7 @@
 #include "RimUiTreeModelPdm.h"
 #include "RiaImageCompareReporter.h"
 #include "RiaImageFileCompare.h"
+#include "cafProgressInfo.h"
 
 namespace caf
 {
@@ -1305,7 +1306,7 @@ bool RIApplication::addEclipseCases(const QStringList& fileNames)
     // 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
-    RigMainGrid* mainGrid = NULL;
+    RigEclipseCase* mainEclipseCase = NULL;
 
     {
         QString firstFileName = fileNames[0];
@@ -1328,9 +1329,11 @@ bool RIApplication::addEclipseCases(const QStringList& fileNames)
 
         m_project->moveEclipseCaseIntoCaseGroup(rimResultReservoir);
 
-        mainGrid = rimResultReservoir->reservoirData()->mainGrid();
+        mainEclipseCase = rimResultReservoir->reservoirData();
     }
 
+    caf::ProgressInfo info(fileNames.size(), "Reading Active Cell data");
+
     for (int i = 1; i < fileNames.size(); i++)
     {
         QString fileName = fileNames[i];
@@ -1346,12 +1349,14 @@ bool RIApplication::addEclipseCases(const QStringList& fileNames)
 
         m_project->reservoirs.push_back(rimResultReservoir);
 
-        if (!rimResultReservoir->openAndReadActiveCellData(mainGrid))
+        if (!rimResultReservoir->openAndReadActiveCellData(mainEclipseCase))
         {
             return false;
         }
 
         m_project->moveEclipseCaseIntoCaseGroup(rimResultReservoir);
+
+        info.setProgress(i);
     }
 
     onProjectOpenedOrClosed();

ApplicationCode/FileInterface/RifEclipseRestartDataAccess.h

@@ -43,8 +43,10 @@ public:
     virtual ~RifEclipseRestartDataAccess();
 
     virtual bool                open(const QStringList& fileSet) = 0;
+    virtual void                setFileSet(const QStringList& fileSet) {};
     virtual void                close() = 0;
 
+    virtual void                setTimeSteps(const QList<QDateTime>& timeSteps) {};
     virtual size_t              timeStepCount() = 0;
     virtual QList<QDateTime>    timeSteps() = 0;
 

ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp

@@ -42,21 +42,20 @@ RifEclipseRestartFilesetAccess::~RifEclipseRestartFilesetAccess()
 //--------------------------------------------------------------------------------------------------
 bool RifEclipseRestartFilesetAccess::open(const QStringList& fileSet)
 {
-    setFileSet(fileSet);
+    if (m_fileNames.size() > 0)
-
+    {
-    int numFiles = fileSet.size();
+        caf::ProgressInfo progInfo(m_fileNames.size(), "");
-
-    caf::ProgressInfo progInfo(numFiles,"");
 
         int i;
-    for (i = 0; i < numFiles; i++)
+        for (i = 0; i < m_fileNames.size(); i++)
         {
-        progInfo.setProgressDescription(fileSet[i]);
+            progInfo.setProgressDescription(m_fileNames[i]);
 
             openTimeStep(i);
 
             progInfo.incrementProgress();
         }
+    }
 
     return true;
 }
@@ -95,12 +94,21 @@ void RifEclipseRestartFilesetAccess::close()
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RifEclipseRestartFilesetAccess::setTimeSteps(const QList<QDateTime>& timeSteps)
+{
+    CVF_ASSERT(m_fileNames.size() == timeSteps.size());
+    m_timeSteps = timeSteps;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// Get the number of time steps
 //--------------------------------------------------------------------------------------------------
 size_t RifEclipseRestartFilesetAccess::timeStepCount()
 {
-    return m_ecl_files.size();
+    return m_timeSteps.size();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -108,9 +116,9 @@ size_t RifEclipseRestartFilesetAccess::timeStepCount()
 //--------------------------------------------------------------------------------------------------
 QList<QDateTime> RifEclipseRestartFilesetAccess::timeSteps()
 {
-    QList<QDateTime> timeSteps;
+    if (m_timeSteps.size() == 0)
-
+    {
-    size_t numSteps = timeStepCount();
+        size_t numSteps = m_fileNames.size();
         size_t i;
         for (i = 0; i < numSteps; i++)
         {
@@ -122,15 +130,17 @@ QList<QDateTime> RifEclipseRestartFilesetAccess::timeSteps()
         
             if (stepTime.size() == 1)
             {
-            timeSteps.push_back(stepTime[0]);
+                m_timeSteps.push_back(stepTime[0]);
             }
             else
             {
-            timeSteps.push_back(QDateTime());
+                m_timeSteps.push_back(QDateTime());
             }
         }
 
-    return timeSteps;
+    }
+
+    return m_timeSteps;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.h

@@ -39,6 +39,7 @@ public:
     void                        setFileSet(const QStringList& fileSet);
     void                        close();
 
+    void                        setTimeSteps(const QList<QDateTime>& timeSteps);
     size_t                      timeStepCount();
     QList<QDateTime>            timeSteps();
 
@@ -52,5 +53,7 @@ private:
 
 private:
     QStringList                     m_fileNames;
+    QList<QDateTime>                m_timeSteps;
+
     std::vector< ecl_file_type* >   m_ecl_files;
 };

ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -392,7 +392,7 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigEclipseCase* eclip
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName, RigEclipseCase* eclipseCase)
+bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName, RigEclipseCase* mainEclipseCase, RigEclipseCase* eclipseCase)
 {
     CVF_ASSERT(eclipseCase);
 
@@ -402,8 +402,6 @@ bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName,
         return false;
     }
 
-    caf::ProgressInfo progInfo(100, "");
-
     close();
 
     // Get set of files
@@ -417,23 +415,21 @@ bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName,
     eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(this);
     eclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(this);
 
-    progInfo.setNextProgressIncrement(50);
-    progInfo.setProgressDescription("Reading active cell information");
-
     if (!readActiveCellInfo())
     {
         return false;
     }
     
-    progInfo.incrementProgress();
-
-    progInfo.setNextProgressIncrement(50);
-    progInfo.setProgressDescription("Reading meta data");
 
     // Reading of metadata and well cells is not performed here
     //if (!buildMetaData()) return false;
     // readWellCells();
 
+    m_dynamicResultsAccess = createDynamicResultsAccess(m_fileSet);
+
+    QList<QDateTime> mainCaseTimeSteps = mainEclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->readerInterface()->timeSteps();
+    m_dynamicResultsAccess->setTimeSteps(mainCaseTimeSteps);
+
     return true;
 }
 
@@ -528,12 +524,14 @@ bool RifReaderEclipseOutput::buildMetaData()
     progInfo.setNextProgressIncrement(m_fileSet.size());
 
     // Create access object for dynamic results
-    m_dynamicResultsAccess = dynamicResultsAccess(m_fileSet);
+    m_dynamicResultsAccess = createDynamicResultsAccess(m_fileSet);
     if (m_dynamicResultsAccess.isNull())
     {
         return false;
     }
 
+    m_dynamicResultsAccess->open(m_fileSet);
+
 
     progInfo.incrementProgress();
 
@@ -573,13 +571,12 @@ bool RifReaderEclipseOutput::buildMetaData()
 
     progInfo.incrementProgress();
 
-    if (!openInitFile())
+    openInitFile();
-    {
-        return false;
-    }
     
     progInfo.incrementProgress();
 
+    if (m_ecl_init_file)
+    {
         QStringList resultNames;
         std::vector<size_t> resultNamesDataItemCounts;
         RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(m_ecl_init_file, &resultNames, &resultNamesDataItemCounts);
@@ -615,6 +612,7 @@ bool RifReaderEclipseOutput::buildMetaData()
                 fractureModelResults->setTimeStepDates(resIndex, staticDate);
             }
         }
+    }
 
     return true;
 }
@@ -622,7 +620,7 @@ bool RifReaderEclipseOutput::buildMetaData()
 //--------------------------------------------------------------------------------------------------
 /// Create results access object (.UNRST or .X0001 ... .XNNNN)
 //--------------------------------------------------------------------------------------------------
-RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const QStringList& fileSet)
+RifEclipseRestartDataAccess* RifReaderEclipseOutput::createDynamicResultsAccess(const QStringList& fileSet)
 {
     RifEclipseRestartDataAccess* resultsAccess = NULL;
 
@@ -631,11 +629,7 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
     if (unrstFileName.size() > 0)
     {
         resultsAccess = new RifEclipseUnifiedRestartFileAccess();
-        if (!resultsAccess->open(QStringList(unrstFileName)))
+        resultsAccess->setFileSet(QStringList(unrstFileName));
-        {
-            delete resultsAccess;
-            return NULL;
-        }
     }
     else
     {
@@ -644,16 +638,9 @@ RifEclipseRestartDataAccess* RifReaderEclipseOutput::dynamicResultsAccess(const
         if (restartFiles.size() > 0)
         {
             resultsAccess = new RifEclipseRestartFilesetAccess();
-            if (!resultsAccess->open(restartFiles))
+            resultsAccess->setFileSet(restartFiles);
-            {
-                delete resultsAccess;
-                return NULL;
         }
     }
-    }
-
-    // !! could add support for formatted result files
-    // !! consider priorities in case multiple types exist (.UNRST, .XNNNN, ...)
 
     return resultsAccess;
 }
@@ -693,7 +680,16 @@ bool RifReaderEclipseOutput::staticResult(const QString& result, PorosityModelRe
 //--------------------------------------------------------------------------------------------------
 bool RifReaderEclipseOutput::dynamicResult(const QString& result, PorosityModelResultType matrixOrFracture, size_t stepIndex, std::vector<double>* values)
 {
-    CVF_ASSERT(m_dynamicResultsAccess.notNull());
+    if (m_dynamicResultsAccess.isNull())
+    {
+        m_dynamicResultsAccess = createDynamicResultsAccess(m_fileSet);
+    }
+
+    if (m_dynamicResultsAccess.isNull())
+    {
+        CVF_ASSERT(false);
+        return false;
+    }
 
     std::vector<double> fileValues;
     if (!m_dynamicResultsAccess->results(result, stepIndex, m_eclipseCase->mainGrid()->gridCount(), &fileValues))
@@ -1020,3 +1016,11 @@ bool RifReaderEclipseOutput::openInitFile()
     return false;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+QList<QDateTime> RifReaderEclipseOutput::timeSteps()
+{
+    return m_timeSteps;
+}
+

ApplicationCode/FileInterface/RifReaderEclipseOutput.h

@@ -44,7 +44,7 @@ public:
     virtual ~RifReaderEclipseOutput();
 
     bool                    open(const QString& fileName, RigEclipseCase* eclipseCase);
-    virtual bool            openAndReadActiveCellData(const QString& fileName, RigEclipseCase* eclipseCase);
+    virtual bool            openAndReadActiveCellData(const QString& fileName, RigEclipseCase* mainEclipseCase, RigEclipseCase* eclipseCase);
     void                    close();
 
     bool                    staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values);
@@ -58,14 +58,15 @@ private:
     void                    readWellCells();
     
     bool                    openInitFile();
+    bool                    openDynamicAccess();
 
     void                    extractResultValuesBasedOnPorosityModel(PorosityModelResultType matrixOrFracture, std::vector<double>* values, const std::vector<double>& fileValues);
     
-    static RifEclipseRestartDataAccess*   staticResultsAccess(const QStringList& fileSet);
+    static RifEclipseRestartDataAccess*   createDynamicResultsAccess(const QStringList& fileSet);
-    static RifEclipseRestartDataAccess*   dynamicResultsAccess(const QStringList& fileSet);
 
     QStringList             validKeywordsForPorosityModel(const QStringList& keywords, const std::vector<size_t>& keywordDataItemCounts, const RigActiveCellInfo* activeCellInfo, PorosityModelResultType matrixOrFracture, size_t timeStepCount) const;
 
+    virtual QList<QDateTime> timeSteps();
 private:
     QString                                 m_fileName;         // Name of file used to start accessing Eclipse output files
     QStringList                             m_fileSet;          // Set of files in filename's path with same base name as filename

ApplicationCode/FileInterface/RifReaderInterface.h

@@ -24,6 +24,7 @@
 
 #include <QString>
 #include <QStringList>
+#include <QDateTime>
 
 
 class RigEclipseCase;
@@ -47,9 +48,11 @@ public:
     virtual ~RifReaderInterface() {}
 
     virtual bool                open(const QString& fileName, RigEclipseCase* eclipseCase) = 0;
-    virtual bool                openAndReadActiveCellData(const QString& fileName, RigEclipseCase* eclipseCase) { return true; };
+    virtual bool                openAndReadActiveCellData(const QString& fileName, RigEclipseCase* mainEclipseCase, RigEclipseCase* eclipseCase) { return true; };
     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 QList<QDateTime>    timeSteps() { QList<QDateTime> timeSteps; return timeSteps; }
 };

ApplicationCode/ProjectDataModel/RimResultReservoir.cpp

@@ -93,7 +93,7 @@ bool RimResultReservoir::openEclipseGridFile()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimResultReservoir::openAndReadActiveCellData(RigMainGrid* mainGrid)
+bool RimResultReservoir::openAndReadActiveCellData(RigEclipseCase* mainEclipseCase)
 {
     cvf::ref<RifReaderInterface> readerInterface;
 
@@ -113,10 +113,12 @@ bool RimResultReservoir::openAndReadActiveCellData(RigMainGrid* mainGrid)
         }
 
         cvf::ref<RigEclipseCase> eclipseCase = new RigEclipseCase;
-        eclipseCase->setMainGrid(mainGrid);
+
+        CVF_ASSERT(mainEclipseCase && mainEclipseCase->mainGrid());
+        eclipseCase->setMainGrid(mainEclipseCase->mainGrid());
 
         readerInterface = new RifReaderEclipseOutput;
-        if (!readerInterface->openAndReadActiveCellData(fname, eclipseCase.p()))
+        if (!readerInterface->openAndReadActiveCellData(fname, mainEclipseCase, eclipseCase.p()))
         {
             return false;
         }

ApplicationCode/ProjectDataModel/RimResultReservoir.h

@@ -46,7 +46,7 @@ public:
     caf::PdmField<QString>      caseDirectory;
 
     virtual bool                openEclipseGridFile();
-    bool                        openAndReadActiveCellData(RigMainGrid* mainGrid);
+    bool                        openAndReadActiveCellData(RigEclipseCase* mainEclipseCase);
 
     //virtual caf::PdmFieldHandle*    userDescriptionField()  { return &caseName;}
 

ApplicationCode/ProjectDataModel/RimStatisticalCalculation.cpp

@@ -152,8 +152,12 @@ void RimStatisticalCalculation::computeStatistics()
     RigStatisticsConfig statisticsConfig;
 
     std::vector<size_t> timeStepIndices;
-    timeStepIndices.push_back(0);
+
-    timeStepIndices.push_back(1);
+    size_t timeStepCount = sourceCases.at(0)->results(RifReaderInterface::MATRIX_RESULTS)->maxTimeStepCount();
+    for (size_t i = 0; i < timeStepCount; i++)
+    {
+        timeStepIndices.push_back(i);
+    }
 
     RigEclipseCase* resultCase = reservoirData();
 

ApplicationCode/ReservoirDataModel/RigEclipseCase.cpp

@@ -408,3 +408,16 @@ cvf::ref<cvf::StructGridScalarDataAccess> RigEclipseCase::dataAccessObject(const
     return NULL;
 
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigEclipseCase::closeReaderInterface()
+{
+    RifReaderInterface* readerInterface = m_matrixModelResults->readerInterface();
+
+    if (readerInterface)
+    {
+        readerInterface->close();
+    }
+}

ApplicationCode/ReservoirDataModel/RigEclipseCase.h

@@ -49,6 +49,8 @@ public:
     RigReservoirCellResults*		        results(RifReaderInterface::PorosityModelResultType porosityModel);
     const RigReservoirCellResults*          results(RifReaderInterface::PorosityModelResultType porosityModel) const;
     
+    void                    closeReaderInterface();
+
     cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject(const RigGridBase* grid, 
                                                                RifReaderInterface::PorosityModelResultType porosityModel, 
                                                                size_t timeStepIndex, 
@@ -74,7 +76,6 @@ private:
     void                    computeWellCellsPrGrid();
     void                    computeActiveCellsGeometryBoundingBox();
 
-
 private:
     RigActiveCellInfo                   m_activeCellInfo;
 

ApplicationCode/ReservoirDataModel/RigReservoirCellResults.cpp

@@ -268,6 +268,61 @@ double RigReservoirCellResults::cellScalarResult( size_t scalarResultIndex, size
     }
 }
 
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+size_t RigReservoirCellResults::findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex)
+{
+    size_t resultGridIndex = cvf::UNDEFINED_SIZE_T;
+
+    resultGridIndex = findScalarResultIndex(type, resultName);
+
+    if (resultGridIndex == cvf::UNDEFINED_SIZE_T)  return cvf::UNDEFINED_SIZE_T;
+
+    if (type == RimDefines::GENERATED)
+    {
+        return cvf::UNDEFINED_SIZE_T;
+    }
+
+    if (m_readerInterface.notNull())
+    {
+        // Add one more result to result container
+        size_t timeStepCount = m_resultInfos[resultGridIndex].m_timeStepDates.size();
+
+        bool resultLoadingSucess = true;
+
+        if (type == RimDefines::DYNAMIC_NATIVE && timeStepCount > 0)
+        {
+            std::vector<double>& values = m_cellScalarResults[resultGridIndex][timeStepIndex];
+            if (values.size() == 0)
+            {
+                if (!m_readerInterface->dynamicResult(resultName, RifReaderInterface::MATRIX_RESULTS, timeStepIndex, &values))
+                {
+                    resultLoadingSucess = false;
+                }
+            }
+        }
+        else if (type == RimDefines::STATIC_NATIVE)
+        {
+            std::vector<double>& values = m_cellScalarResults[resultGridIndex][0];
+            if (!m_readerInterface->staticResult(resultName, RifReaderInterface::MATRIX_RESULTS, &values))
+            {
+                resultLoadingSucess = false;
+            }
+        }
+
+        if (!resultLoadingSucess)
+        {
+            // Error logging
+            CVF_ASSERT(false);
+        }
+    }
+
+    return resultGridIndex;
+
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -336,6 +391,15 @@ void RigReservoirCellResults::setReaderInterface(RifReaderInterface* readerInter
     m_readerInterface = readerInterface;
 }
 
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RifReaderInterface* RigReservoirCellResults::readerInterface()
+{
+    return m_readerInterface.p();
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -697,12 +761,15 @@ void RigReservoirCellResults::setTimeStepDates(size_t scalarResultIndex, const Q
 //--------------------------------------------------------------------------------------------------
 size_t RigReservoirCellResults::maxTimeStepCount() const
 {
-    size_t maxTsCount = 0;
+    int maxTsCount = 0;
-    for (size_t i = 0; i < m_cellScalarResults.size(); ++i)
+
+    std::vector<ResultInfo>::const_iterator it;
+    for (it = m_resultInfos.begin(); it != m_resultInfos.end(); it++)
     {
-       maxTsCount =  m_cellScalarResults[i].size() > maxTsCount ? m_cellScalarResults[i].size() : maxTsCount;
+        maxTsCount = it->m_timeStepDates.size() > maxTsCount ? it->m_timeStepDates.size() : maxTsCount;
     } 
-    return maxTsCount;
+
+    return static_cast<size_t>(maxTsCount);
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ReservoirDataModel/RigReservoirCellResults.h

@@ -36,6 +36,7 @@ public:
     RigReservoirCellResults(RigMainGrid* ownerGrid);
 
     void                setReaderInterface(RifReaderInterface* readerInterface);
+    RifReaderInterface* readerInterface();
 
     // Max and min values of the results
     void                recalculateMinMax(size_t scalarResultIndex);
@@ -57,6 +58,7 @@ public:
     void                setTimeStepDates(size_t scalarResultIndex, const QList<QDateTime>& dates);
 
     // Find or create a slot for the results
+    size_t              findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex);
     size_t              findOrLoadScalarResult(RimDefines::ResultCatType type, const QString& resultName);
     size_t              findOrLoadScalarResult(const QString& resultName); ///< Simplified search. Assumes unique names across types.
     size_t              findScalarResultIndex(RimDefines::ResultCatType type, const QString& resultName) const;

ApplicationCode/ReservoirDataModel/RigStatistics.cpp

@@ -20,6 +20,7 @@
 #include "RigReservoirCellResults.h"
 
 #include <QDebug>
+#include "cafProgressInfo.h"
 
 //--------------------------------------------------------------------------------------------------
 /// 
@@ -36,7 +37,7 @@ void RigStatistics::addNamedResult(RigReservoirCellResults* cellResults, RimDefi
     std::vector< std::vector<double> >& dataValues = cellResults->cellScalarResults(resultIndexMin);
     dataValues.resize(timeStepDates.size());
 
-    for (size_t i = 0; i < timeStepDates.size(); i++)
+    for (int i = 0; i < timeStepDates.size(); i++)
     {
         dataValues[i].resize(activeCellCount, HUGE_VAL);
     }
@@ -109,6 +110,8 @@ void RigStatistics::evaluateStatistics(RimDefines::ResultCatType resultType, con
 
     computeActiveCellUnion();
 
+    buildSourceMetaData(resultType, resultName);
+
     QString minResultName = resultName + "_MIN";
     QString maxResultName = resultName + "_MAX";
     QString meanResultName = resultName + "_MEAN";
@@ -127,6 +130,8 @@ void RigStatistics::evaluateStatistics(RimDefines::ResultCatType resultType, con
 
     if (activeMatrixCellCount > 0)
     {
+        caf::ProgressInfo info(m_timeStepIndices.size(), "Computing Statistics");
+
         for (size_t timeIndicesIdx = 0; timeIndicesIdx < m_timeStepIndices.size(); timeIndicesIdx++)
         {
             size_t timeStepIdx = m_timeStepIndices[timeIndicesIdx];
@@ -142,7 +147,7 @@ void RigStatistics::evaluateStatistics(RimDefines::ResultCatType resultType, con
                 {
                     RigEclipseCase* eclipseCase = m_sourceCases.at(caseIdx);
 
-                    size_t scalarResultIndex = eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(resultName);
+                    size_t scalarResultIndex = eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResultForTimeStep(resultType, resultName, timeStepIdx);
 
                     cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject = eclipseCase->dataAccessObject(grid, RifReaderInterface::MATRIX_RESULTS, timeStepIdx, scalarResultIndex);
                     if (dataAccessObject.notNull())
@@ -227,6 +232,19 @@ void RigStatistics::evaluateStatistics(RimDefines::ResultCatType resultType, con
                     }
                 }
             }
+
+            for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++)
+            {
+                RigEclipseCase* eclipseCase = m_sourceCases.at(caseIdx);
+
+                // When one time step is completed, close all result files.
+                // Microsoft note: On Windows, the maximum number of files open at the same time is 512
+                // http://msdn.microsoft.com/en-us/library/kdfaxaay%28vs.71%29.aspx
+                //
+                eclipseCase->closeReaderInterface();
+            }
+
+            info.setProgress(timeIndicesIdx);
         }
     }
 }
@@ -264,3 +282,27 @@ RigStatistics::RigStatistics(cvf::Collection<RigEclipseCase>& sourceCases, const
         m_globalCellCount = sourceCases[0]->mainGrid()->cells().size();
     }
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigStatistics::buildSourceMetaData(RimDefines::ResultCatType resultType, const QString& resultName)
+{
+    for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++)
+    {
+        RigEclipseCase* eclipseCase = m_sourceCases.at(caseIdx);
+
+        RigReservoirCellResults* matrixResults = eclipseCase->results(RifReaderInterface::MATRIX_RESULTS);
+        size_t scalarResultIndex = matrixResults->findOrLoadScalarResult(resultType, resultName);
+        if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
+        {
+            QList<QDateTime> timeStepDates = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->timeStepDates(0);
+
+            size_t scalarResultIndex = matrixResults->addEmptyScalarResult(resultType, resultName);
+            matrixResults->setTimeStepDates(scalarResultIndex, timeStepDates);
+
+            std::vector< std::vector<double> >& dataValues = matrixResults->cellScalarResults(scalarResultIndex);
+            dataValues.resize(timeStepDates.size());
+        }
+    }
+}

ApplicationCode/ReservoirDataModel/RigStatistics.h

@@ -135,7 +135,7 @@ public:
 private:
     void computeActiveCellUnion();
     void addNamedResult(RigReservoirCellResults* cellResults, RimDefines::ResultCatType resultType, const QString& resultName, size_t activeCellCount);
-
+    void buildSourceMetaData( RimDefines::ResultCatType resultType, const QString& resultName );
 private:
     cvf::Collection<RigEclipseCase> m_sourceCases;
     std::vector<size_t>             m_timeStepIndices;